#pragma once
#include<iostream>
#include<vector>
using namespace std;

namespace CloseHash
{
	//枚举每个位置的状态
	enum State
	{
		EMPTY,
		DELETE,
		EXIST
	};
	//每个位置数据类型
	template<class K, class V>
	class HashData
	{
	public:
		pair<K, V> _kv;
		State _state = EMPTY;
	};
	//哈希表
	template<class K, class V>
	class HashTable
	{
	public:
		bool insert(const pair<K,V>& kv)
		{
			if ()
			{

			}
			//扩容
			if (_tables.size() == 0 || _size * 10 / _tables.size() >= 7)
			{
				size_t NewSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				HashTable<K, V> NewHT;
				NewHT._tables.resize(NewSize);
				for (HashData<K, V> e : tables)
				{
					if (e._state == EXIST)
					{
						NewHT.insert(e._kv);
					}
				}
				tables.swap(NewHT._tables);
			}

			//线性探测
			size_t hashi = kv.first % _tables.size();
			//HashData<K, V> NewData = new HashData<K, V>(kv);
			while (_tables[hashi]._state == EXIST)
			{
				hashi++;
				hashi %= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			_size++;
		}
		bool find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = key % _tables.size();
			size_t start = hashi;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				hashi++;
				hashi %= _tables.size();

				if (hashi == start)
				{
					break;
				}
			}
			return nullptr;
		}
	private:
		vector<HashData<K, V>> _tables;
		size_t _size = 0;
	};
}
//namespace HashBucket
//{
//
//}